/**
 * AI回复格式处理工具
 */
import { AIResponseParseResult } from '../../types/ai.ts';

// 标准格式标签
const STANDARD_TAGS = {
  startTag: '【润色结果】',
  endTag: '【/润色结果】',
};

// 常见的变体标签
const VARIANT_TAGS = [
  { startTag: '【润色结果】', endTag: '【/】' },
  { startTag: '【润色结果】', endTag: '【/结果】' },
  { startTag: '【润色后文本】', endTag: '【/润色后文本】' },
  { startTag: '【润色后】', endTag: '【/润色后】' },
  { startTag: '【润色内容】', endTag: '【/润色内容】' },
  { startTag: '【润色版本】', endTag: '【/润色版本】' },
  { startTag: '润色结果：', endTag: '' },  // 冒号开头的变体
  { startTag: '【润色结果】', endTag: '' }, // 中文方括号变体
  // 兼容旧的标签格式
  { startTag: '<润色结果>', endTag: '</润色结果>' },
  { startTag: '<润色结果>', endTag: '</>' },
  { startTag: '<润色结果>', endTag: '</结果>' },
  { startTag: '<润色后文本>', endTag: '</润色后文本>' },
];

/**
 * 从AI响应中提取润色结果
 * @param aiResponse AI的原始响应文本
 * @returns 提取结果，包含润色文本和状态信息
 */
export const extractPolishedText = (aiResponse: string): AIResponseParseResult => {
  // 使用更灵活的正则表达式匹配多种结束标记形式
  // 1. 标准格式：【润色结果】...【/润色结果】
  // 2. 简化格式：【润色结果】...【/】
  // 3. 错误格式：【润色结果】.../
  const regex = /【润色结果】([\s\S]*?)(【\/润色结果】|【\/】|\/)/;
  const match = aiResponse.match(regex);
  
  if (match && match[1]) {
    // 提取真正的内容部分(去除结束标记)
    return {
      polishedText: match[1].trim(),
      hasExpectedFormat: true,
      originalTextIncluded: false,
      detectionMethod: 'template-format'
    };
  }

  // 尝试旧格式 <润色结果>...</润色结果>，同样支持多种结束标记
  const oldFormatRegex = /<润色结果>([\s\S]*?)(<\/润色结果>|<\/>|\/)/;
  const oldFormatMatch = aiResponse.match(oldFormatRegex);
  
  if (oldFormatMatch && oldFormatMatch[1]) {
    return {
      polishedText: oldFormatMatch[1].trim(),
      hasExpectedFormat: true,
      originalTextIncluded: false,
      detectionMethod: 'old-format'
    };
  }
  
  // 尝试识别常见的按行分隔格式
  if (aiResponse.includes('原文：') && 
     (aiResponse.includes('润色后：') || aiResponse.includes('润色结果：') || aiResponse.includes('修改后：'))) {
    
    // 按行分割
    const lines = aiResponse.split('\n');
    let foundOriginal = false;
    let foundPolished = false;
    let polishedStart = -1;
    let polishedEnd = -1;
    
    for (let i = 0; i < lines.length; i++) {
      // 查找原文标记
      if (!foundOriginal && (lines[i].includes('原文：') || lines[i].includes('原始文本：'))) {
        foundOriginal = true;
        continue;
      }
      
      // 查找润色后标记
      if (foundOriginal && !foundPolished && 
          (lines[i].includes('润色后：') || lines[i].includes('润色结果：') || lines[i].includes('修改后：'))) {
        foundPolished = true;
        polishedStart = i + 1;
        continue;
      }
      
      // 找到润色后的末尾（通常是解释开始处）
      if (foundPolished && polishedStart > 0 && 
          (lines[i].includes('修改说明：') || lines[i].includes('解释：') || lines[i].includes('分析：'))) {
        polishedEnd = i - 1;
        break;
      }
    }
    
    // 如果找到了润色开始但没找到结束，就认为到最后一行
    if (foundPolished && polishedStart > 0 && polishedEnd < 0) {
      polishedEnd = lines.length - 1;
    }
    
    // 提取润色文本
    if (foundPolished && polishedStart > 0 && polishedEnd >= polishedStart) {
      const polishedText = lines.slice(polishedStart, polishedEnd + 1).join('\n').trim();
      return {
        polishedText,
        hasExpectedFormat: false,
        hasNonStandardFormat: true,
        originalTextIncluded: foundOriginal,
        detectionMethod: 'line-based'
      };
    }
  }
  
  // 尝试识别段落分隔
  const sections = aiResponse.split(/\n\s*\n/);
  
  // 过滤空章节
  const filteredSections = sections
    .map(section => section.trim())
    .filter(section => section.length > 0);
  
  // 检查最后一个章节，通常润色结果会放在最后
  const lastSection = filteredSections[filteredSections.length - 1];
  const secondLastSection = filteredSections.length > 2 ? filteredSections[filteredSections.length - 2] : null;
  
  // 检查最后一段是否包含常见的润色开头提示词
  const polishIndicators = ['润色', '修改后', '修改版', '优化后', '优化版', '结果如下'];
  
  if (secondLastSection && polishIndicators.some(indicator => secondLastSection.includes(indicator))) {
    return {
      polishedText: lastSection.trim(),
      hasExpectedFormat: false,
      hasNonStandardFormat: true,
      originalTextIncluded: false,
      detectionMethod: 'section-based'
    };
  }
  
  // 作为最后的回退，尝试用启发式算法判断
  const potentialResult = tryHeuristicExtraction(aiResponse);
  if (potentialResult) {
    return {
      polishedText: potentialResult,
      hasExpectedFormat: false,
      hasNonStandardFormat: true,
      originalTextIncluded: false,
      detectionMethod: 'heuristic'
    };
  }
  
  // 最后回退到原始响应
  return {
    polishedText: aiResponse,
    hasExpectedFormat: false,
    originalTextIncluded: false,
    detectionMethod: 'fallback'
  };
};

/**
 * 在文本中提取两个标签之间的内容
 * @param text 要搜索的文本
 * @param startTag 开始标签
 * @param endTag 结束标签 (可选)
 * @returns 提取出的内容，未找到则返回null
 */
function extractBetweenTags(text: string, startTag: string, endTag: string): string | null {
  if (!text) return null;
  
  const startIndex = text.indexOf(startTag);
  if (startIndex === -1) return null;
  
  const contentStartIndex = startIndex + startTag.length;
  
  // 如果没有提供结束标签或结束标签为空，则返回标签后面的所有内容
  if (!endTag) {
    return text.substring(contentStartIndex);
  }
  
  const endIndex = text.indexOf(endTag, contentStartIndex);
  
  // 如果找不到结束标签，但找到了开始标签，可以返回从开始标签到结尾的内容
  if (endIndex === -1) {
    // 尝试寻找通用结束标记：双换行或分割线
    const nextSectionIndex = findNextSectionBreak(text, contentStartIndex);
    if (nextSectionIndex !== -1) {
      return text.substring(contentStartIndex, nextSectionIndex);
    }
    
    // 如果仍找不到合适的结束，返回剩余全部内容
    return text.substring(contentStartIndex);
  }
  
  return text.substring(contentStartIndex, endIndex);
}

/**
 * 查找文本中的下一个部分分隔点（双换行或分隔线）
 */
function findNextSectionBreak(text: string, startFrom: number): number {
  // 寻找双换行
  const doubleNewlineIndex = text.indexOf('\n\n', startFrom);
  
  // 寻找常见的Markdown分隔线
  const horizontalRulePatterns = ['\n---\n', '\n___\n', '\n***\n', '\n----\n'];
  let hrIndices = horizontalRulePatterns
    .map(pattern => text.indexOf(pattern, startFrom))
    .filter(index => index !== -1);
  
  if (hrIndices.length === 0 && doubleNewlineIndex === -1) {
    return -1;
  }
  
  // 找出最近的分隔点
  if (doubleNewlineIndex !== -1) {
    hrIndices.push(doubleNewlineIndex);
  }
  
  return Math.min(...hrIndices);
}

/**
 * 将文本按段落或章节分开
 */
function splitToSections(text: string): string[] {
  // 首先按双换行分割
  const sections = text.split(/\n\s*\n/);
  
  // 过滤空章节
  return sections
    .map(section => section.trim())
    .filter(section => section.length > 0);
}

/**
 * 尝试使用启发式方法提取润色结果
 */
function tryHeuristicExtraction(text: string): string | null {
  const lines = text.split('\n');
  
  // 尝试找到含有"润色"，"结果"等关键词的行作为分隔点
  const keywordLines = lines.reduce((acc, line, index) => {
    if (/润色|修改|优化|结果/.test(line)) {
      acc.push({ index, line });
    }
    return acc;
  }, [] as { index: number, line: string }[]);
  
  if (keywordLines.length > 0) {
    // 找到最后一个关键词行后的内容
    const lastKeywordLine = keywordLines[keywordLines.length - 1];
    if (lastKeywordLine.index < lines.length - 1) {
      return lines.slice(lastKeywordLine.index + 1).join('\n').trim();
    }
  }
  
  // 如果找不到关键词，但文本不太长，可以直接使用
  if (text.length < 1000 && !text.includes('```') && !text.includes('例如')) {
    return text;
  }
  
  return null;
}

/**
 * 验证润色结果格式
 * 检查文本是否符合预期的润色结果格式（包括扩展的格式）
 * @param text 要验证的文本
 * @returns 是否符合格式
 */
export const validatePolishFormat = (text: string): boolean => {
  if (!text) return false;
  
  // 检查标准格式
  if (text.includes(STANDARD_TAGS.startTag) && text.includes(STANDARD_TAGS.endTag)) {
    return true;
  }
  
  // 检查变体格式
  for (const format of VARIANT_TAGS) {
    if (text.includes(format.startTag) && (format.endTag === '' || text.includes(format.endTag))) {
      return true;
    }
  }
  
  return false;
};

/**
 * 手动从文本中提取可能的润色结果
 * 适用于AI没有使用预期格式时，用户手动选择结果
 * @param text 完整的AI回复文本
 * @returns 可能的润色结果段落数组
 */
export const extractPotentialResults = (text: string): string[] => {
  // 获取文本的所有段落
  const sections = splitToSections(text);
  
  // 过滤掉明显不是结果的段落（例如解释性文本）
  const filteredSections = sections.filter(section => {
    // 排除包含代码块的段落
    if (section.includes('```')) return false;
    
    // 排除太短的段落（至少20个字符）
    if (section.length < 20) return false;
    
    // 排除明显是解释的段落
    if (/^(我已经|我帮你|根据要求|我根据|希望这个)/.test(section)) return false;
    if (/^(这个润色|这个修改|以上是|如有需要)/.test(section)) return false;
    
    return true;
  });
  
  return filteredSections;
}; 